// 全局变量
let stompClient = window.stompClient || null;
const sessionId = document.querySelector('meta[name="session-id"]')?.content || '';
let isGenerating = false;
let currentMessageContainer = null;
let currentMessageContent = null;

// Markdown处理相关变量
let markdownBuffer = ''; // 累积的Markdown文本
let inCodeBlock = false; // 是否在代码块中
/**
 * 流式聊天功能模块
 * 处理DeepSeek API流式响应的前端逻辑
 */
$(document).ready(function() {
    // 全局变量
    const sessionId = document.querySelector('meta[name="session-id"]')?.content || '';
    let isGenerating = false;
    let currentMessageContainer = null;
    let currentMessageContent = null;

    // 确保所需库已加载
    ensureLibrariesLoaded();

    // 初始化
    initStreamingChat();


    /**
     * 初始化流式聊天功能
     */
    function initStreamingChat() {
        // 订阅流式令牌的WebSocket主题
        if (stompClient && stompClient.connected) {
            subscribeToTopics();
        } else {
            // 如果WebSocket未连接，等待连接完成
            const checkInterval = setInterval(function() {
                if (stompClient && stompClient.connected) {
                    subscribeToTopics();
                    clearInterval(checkInterval);
                }
            }, 100);
        }

        // 替换原有发送按钮事件
        overrideSendButton();

        // 初始化停止生成按钮
        initStopGenerationButton();

        // 在这里添加marked初始化代码
        // 初始化marked设置（如果可用）
        if (typeof marked !== 'undefined') {
            marked.setOptions({
                renderer: new marked.Renderer(),
                highlight: function(code, lang) {
                    if (Prism && lang && Prism.languages[lang]) {
                        return Prism.highlight(code, Prism.languages[lang], lang);
                    }
                    return code;
                },
                pedantic: false,
                gfm: true,
                breaks: true,
                sanitize: false,
                smartypants: false,
                xhtml: false
            });
            console.log('Marked.js已初始化');
        } else {
            console.warn('Marked.js未加载，将使用基本文本渲染');
        }

        // 将处理函数暴露到全局作用域，以便index.js中的WebSocket可以调用
        window.handleTokenUpdate = handleTokenUpdate;
        window.handleGenerationComplete = handleGenerationComplete;
        window.sendStreamingMessage = sendStreamingMessage;
    }

    /**
     * 订阅WebSocket主题
     */
    function subscribeToTopics() {
        // 订阅流式令牌更新
        stompClient.subscribe('/topic/stream/' + sessionId, function(tokenOutput) {
            handleTokenUpdate(tokenOutput.body);
        });

        // 订阅生成完成通知
        stompClient.subscribe('/topic/complete/' + sessionId, function(completeOutput) {
            handleGenerationComplete(completeOutput.body);
        });
    }

    /**
     * 覆盖原有发送按钮事件
     */
    function overrideSendButton() {
        // 注销所有已存在的点击事件，避免重复
        $('#sendButton').off('click');

        // 添加新的点击事件
        $('#sendButton').on('click', function() {
            const messageInput = $('#messageInput');
            const message = messageInput.val().trim();

            if (message !== '') {
                sendStreamingMessage(message);
                messageInput.val('');
                messageInput.css('height', 'auto');
                $('#sendButton').prop('disabled', true);
            }
        });

        // 确保键盘事件处理不冲突
        $('#messageInput').off('keydown.streamChat');
        $('#messageInput').on('keydown.streamChat', function(e) {
            if (e.which === 13 && !e.shiftKey) { // Enter键但不按Shift
                e.preventDefault();
                if (this.value.trim() !== '') {
                    const message = this.value.trim();
                    sendStreamingMessage(message);
                    $(this).val('');
                    $(this).css('height', 'auto');
                    $('#sendButton').prop('disabled', true);
                }
                return false;
            }
        });
    }

    /**
     * 初始化停止生成按钮
     */
    function initStopGenerationButton() {
        $('#stopGeneration').off('click');
        $('#stopGeneration').on('click', function() {
            stopGeneration();
        });
    }

    function sendStreamingMessage(message) {
        console.log('发送消息:', message);

        if (isGenerating) {
            showToast('warning', '请等待', '正在生成回复，请稍候...');
            return;
        }

        // // 立即显示用户消息
        displayUserMessage(message);
        // 显示用户消息

        // 清空输入框 - 强调这一步，确保执行
        $('#messageInput').val('');
        $('#messageInput').css('height', 'auto');
        $('#sendButton').prop('disabled', true);
        console.log('输入框已清空');

        // 确保欢迎页面被移除
        checkAndRemoveWelcomeScreen();

        // 准备接收助手回复
        prepareAssistantMessage();

        // 标记正在生成
        isGenerating = true;

        // 显示停止生成按钮
        $('#stopGeneration').show();

        // 发送API请求
        $.ajax({
            url: '/api/stream/chat/' + sessionId + '/send',
            type: 'POST',
            data: { message: message },
            success: function(response) {
                console.log('流式消息发送成功', response);
            },
            error: function(error) {
                console.error('发送消息错误', error);
                $('#typingIndicator').hide();

                // 移除正在准备的消息容器
                if (currentMessageContainer) {
                    currentMessageContainer.remove();
                    currentMessageContainer = null;
                    currentMessageContent = null;
                }

                // 显示错误消息
                displayErrorMessage('发送消息时出错，请稍后再试。');

                isGenerating = false;
                $('#stopGeneration').hide();

                showToast('error', '发送失败', '无法发送消息，请检查网络连接。');
            }
        });
    }



    /**
     * 确保欢迎页面被移除
     */
    function checkAndRemoveWelcomeScreen() {
        // 检查欢迎页面是否存在
        if ($('#messageList .welcome-screen').length > 0) {
            console.log('移除欢迎页面');

            // 清空消息列表
            $('#messageList').empty();

            // 添加日期分隔符
            const dateDivider = $('<div class="message-date-divider"><span>' +
                formatDate(new Date(), 'yyyy年MM月dd日') + '</span></div>');
            $('#messageList').append(dateDivider);
        }
    }

    /**
     * 格式化日期 - 备用实现
     */
    function formatDate(date, format) {
        const year = date.getFullYear();
        const month = date.getMonth() + 1;
        const day = date.getDate();
        const hours = date.getHours();
        const minutes = date.getMinutes();
        const seconds = date.getSeconds();

        format = format.replace('yyyy', year);
        format = format.replace('MM', month.toString().padStart(2, '0'));
        format = format.replace('dd', day.toString().padStart(2, '0'));
        format = format.replace('HH', hours.toString().padStart(2, '0'));
        format = format.replace('mm', minutes.toString().padStart(2, '0'));
        format = format.replace('ss', seconds.toString().padStart(2, '0'));

        return format;
    }

    /**
     * 简单的用户消息显示函数 (当index.js中的showMessage不可用时)
     */
// 修改displayUserMessage确保它可以正确处理字符串
    function displayUserMessage(message) {
        console.log('显示用户消息:', message);

        // 确保message是字符串
        const content = typeof message === 'object' ? message.content : message;

        // 检查消息是否为空
        if (!content || content.trim() === '') {
            console.warn('尝试显示空消息');
            return;
        }

        const messageContainer = $('<div class="message-container"></div>');

        // 创建头像
        const avatarElement = $('<div class="message-avatar user"></div>')
            .append($('<i class="fas fa-user"></i>'));

        messageContainer.append(avatarElement);

        // 创建消息内容
        const messageContent = $('<div class="message-content"></div>');
        const messageBubble = $('<div class="message-bubble user"></div>')
            .append($('<div></div>').html(content.replace(/\n/g, '<br>')));

        messageContent.append(messageBubble);

        // 添加时间戳
        const timestamp = new Date();
        const timeString = formatTime ? formatTime(timestamp) :
            formatDate ? formatDate(timestamp, 'HH:mm:ss') :
                timestamp.toLocaleTimeString();

        messageContent.append($('<div class="message-meta"></div>').text(timeString));

        messageContainer.append(messageContent);

        // 添加到消息列表
        $('#messageList').append(messageContainer);
        console.log(messageContainer)

        // 滚动到底部
        try {
            scrollToBottom();
        } catch (e) {
            console.error('滚动到底部失败:', e);
            const messageList = document.getElementById('messageList');
            if (messageList) {
                messageList.scrollTop = messageList.scrollHeight;
            }
        }

        console.log('用户消息已添加到DOM');
    }

    /**
     * 简单的错误消息显示函数 (当index.js中的showMessage不可用时)
     */
    function displayErrorMessage(message) {
        const messageContainer = $('<div class="message-container"></div>');

        // 创建头像
        const avatarElement = $('<div class="message-avatar"></div>')
            .append($('<i class="fas fa-robot"></i>'));

        messageContainer.append(avatarElement);

        // 创建消息内容
        const messageContent = $('<div class="message-content"></div>');
        const messageBubble = $('<div class="message-bubble assistant"></div>')
            .append($('<div></div>').html(message.replace(/\n/g, '<br>')));

        messageContent.append(messageBubble);

        // 添加时间戳
        const timestamp = new Date();
        const timeString = formatDate(timestamp, 'HH:mm:ss');
        messageContent.append($('<div class="message-meta"></div>').text(timeString));

        messageContainer.append(messageContent);
        $('#messageList').append(messageContainer);
        scrollToBottom();
    }

    /**
     * 准备接收助手消息的容器
     */
    function prepareAssistantMessage() {
        // 创建消息容器
        currentMessageContainer = $('<div class="message-container"></div>');

        // 创建头像
        const avatarElement = $('<div class="message-avatar"></div>')
            .append($('<i class="fas fa-robot"></i>'));

        currentMessageContainer.append(avatarElement);

        // 创建消息内容
        const messageContent = $('<div class="message-content"></div>');
        const messageBubble = $('<div class="message-bubble assistant"></div>');
        currentMessageContent = $('<div class="streaming-content"></div>');
        messageBubble.append(currentMessageContent);

        // 添加正在输入指示器
        const typingIndicator = $('<div class="typing-indicator"><span></span><span></span><span></span></div>');
        messageBubble.append(typingIndicator);

        messageContent.append(messageBubble);

        // 添加时间戳
        const timestamp = new Date();
        const timeString = formatDate(timestamp, 'HH:mm:ss');
        messageContent.append($('<div class="message-meta"></div>').text(timeString));

        currentMessageContainer.append(messageContent);
        $('#messageList').append(currentMessageContainer);
        scrollToBottom();
    }

    /**
     * 处理令牌更新，支持实时Markdown预览
     * @param {string} token 新的令牌文本
     */
// 添加防抖功能，减少频繁DOM更新
    let updateTimeout = null;
    const UPDATE_DELAY = 50; // 50毫秒的延迟

    /**
     * 优化后的handleTokenUpdate函数
     */
    function handleTokenUpdate(token) {
        if (!currentMessageContent) return;

        // 隐藏输入指示器
        currentMessageContent.siblings('.typing-indicator').hide();

        // 检查是否是错误消息
        if (token.startsWith("[ERROR]")) {
            // 显示错误消息
            let errorMsg = token.substring(7); // 移除 "[ERROR]" 前缀
            currentMessageContent.html(`<div class="error-message"><i class="fas fa-exclamation-circle"></i> ${errorMsg}</div>`);
            // 添加错误样式
            currentMessageContent.parent().addClass('error');

            // 不要直接返回！触发完成事件，重置状态
            setTimeout(function() {
                isGenerating = false;
                $('#stopGeneration').hide();

                // 重置状态
                markdownBuffer = '';
                inCodeBlock = false;
                currentMessageContainer = null;
                currentMessageContent = null;
            }, 100);

            return;
        }
        // 追加新的令牌到原始文本中
        markdownBuffer = (markdownBuffer || '') + token;

        // 使用防抖减少更新频率
        clearTimeout(updateTimeout);
        updateTimeout = setTimeout(function() {
            updateRenderedContent();
        }, UPDATE_DELAY);
    }

    /**
     * 更新渲染的内容
     */
    function updateRenderedContent() {
        try {
            if (!currentMessageContent) return;

            // 使用marked.js将累积的markdown转换为HTML
            let renderedHtml;
            if (typeof marked !== 'undefined') {
                // 使用marked进行转换
                renderedHtml = marked.parse(markdownBuffer);
            } else {
                // 降级处理：基本HTML转义
                renderedHtml = markdownBuffer
                    .replace(/</g, '&lt;')
                    .replace(/>/g, '&gt;')
                    .replace(/\n/g, '<br>');
            }

            // 更新DOM
            currentMessageContent.html(renderedHtml);

            // 应用代码高亮
            if (typeof Prism !== 'undefined') {
                try {
                    Prism.highlightAllUnder(currentMessageContent[0]);
                } catch (e) {
                    console.error('代码高亮失败:', e);
                }
            }

            // 滚动到底部
            scrollToBottom();
        } catch (error) {
            console.error('渲染Markdown出错:', error);
            // 降级处理：直接显示文本
            currentMessageContent.text(markdownBuffer);
        }
    }

    /**
     * 检测是否处于代码块中或开始/结束代码块
     */
    function detectCodeBlock(currentText, token) {
        // 检测代码块开始 ```
        if (token === '`' && currentText.endsWith('``')) {
            return true;
        }

        // 检测代码块结束 ```
        if (token === '`' && currentText.includes('```') &&
            !currentText.split('```').pop().includes('```')) {
            return true;
        }

        // 正在代码块内
        return currentText.split('```').length % 2 === 0;
    }

    /**
     * 处理代码块格式
     */
    function processCodeBlock(currentText, token) {
        // 代码块开始
        if (token === '`' && currentText.endsWith('``')) {
            return currentText + token + '<pre><code>';
        }

        // 代码块结束
        if (token === '`' && currentText.includes('```') &&
            !currentText.split('```').pop().includes('```')) {
            return currentText + token + '</code></pre>';
        }

        // 在代码块内
        return currentText + escapeHtml(token);
    }

    /**
     * HTML转义
     */
    function escapeHtml(text) {
        const map = {
            '&': '&amp;',
            '<': '&lt;',
            '>': '&gt;',
            '"': '&quot;',
            "'": '&#039;'
        };
        return text.replace(/[&<>"']/g, function(m) { return map[m]; });
    }

    /**
     * 处理生成完成
     * @param {string|Object} completeData 完成数据
     */
    function handleGenerationComplete(completeData) {
        isGenerating = false;
        $('#stopGeneration').hide();

        // 处理错误情况 - 支持两种格式
        if (completeData === 'error' ||
            completeData === 'done' ||  // 添加对新的"done"标记的支持
            (typeof completeData === 'object' && completeData.role === 'assistant' &&
                completeData.content && completeData.content.includes("[ERROR]"))) {

            if (currentMessageContent) {
                // 显示通用错误消息或使用已有的错误消息
                if (completeData === 'done') {
                    // 如果收到"done"标记，不做任何处理
                } else if (typeof completeData === 'object' && completeData.content) {
                    // 如果是对象格式且内容已包含[ERROR]前缀，则直接使用该内容
                    const errorContent = completeData.content;
                    if (!errorContent.startsWith("<div class=\"error-message\">")) {
                        // 只有在尚未格式化的情况下才添加样式
                        currentMessageContent.html(`<div class="error-message"><i class="fas fa-exclamation-circle"></i> ${errorContent}</div>`);
                        currentMessageContent.parent().addClass('error');
                    }
                } else if (completeData === 'error') {
                    // 显示通用错误消息
                    currentMessageContent.html('<div class="error-message"><i class="fas fa-exclamation-circle"></i> 生成回复时出错，请稍后再试。</div>');
                    currentMessageContent.parent().addClass('error');
                }
            }

            // 重置状态
            markdownBuffer = '';
            inCodeBlock = false;
            currentMessageContainer = null;
            currentMessageContent = null;
            return;
        }

        try {
            // 解析数据
            let assistantMessage;
            if (typeof completeData === 'string') {
                try {
                    assistantMessage = JSON.parse(completeData);
                } catch (e) {
                    console.error('JSON解析失败:', e);
                    assistantMessage = { content: completeData };
                }
            } else {
                assistantMessage = completeData;
            }

            // 确保我们有内容可以显示
            if (!assistantMessage || !assistantMessage.content) {
                console.error('无效的助手消息:', assistantMessage);
                if (currentMessageContent) {
                    currentMessageContent.html('<div class="error-message">无法解析回复内容</div>');
                }
                return;
            }

            // 应用内容 - 使用marked进行Markdown渲染
            if (currentMessageContent) {
                let finalContent = assistantMessage.content;

                try {
                    if (typeof marked !== 'undefined') {
                        // 使用marked渲染Markdown
                        finalContent = marked.parse(finalContent);
                    }

                    // 设置处理后的内容
                    currentMessageContent.html(finalContent);

                    // 应用代码高亮
                    setTimeout(function() {
                        if (typeof Prism !== 'undefined' && currentMessageContent && currentMessageContent[0]) {
                            try {
                                // 确保DOM元素存在
                                const codeElements = currentMessageContent[0].querySelectorAll('pre code');
                                if (codeElements && codeElements.length > 0) {
                                    // 手动对每个代码块应用高亮
                                    codeElements.forEach(function(element) {
                                        Prism.highlightElement(element);
                                    });
                                } else {
                                    // 如果找不到特定元素，尝试整体高亮
                                    Prism.highlightAllUnder(currentMessageContent[0]);
                                }
                            } catch (e) {
                                console.error('代码高亮失败:', e);
                            }
                        }
                    }, 100);
                } catch (e) {
                    console.error('Markdown渲染失败:', e);
                    // 降级处理：直接显示内容
                    currentMessageContent.html(finalContent);
                }
            }
        } catch (e) {
            console.error('处理完成数据出错:', e);
            if (currentMessageContent) {
                currentMessageContent.html('<div class="error-message">处理回复数据时出错：' + e.message + '</div>');
            }
        } finally {
            // 重置状态
            markdownBuffer = '';
            inCodeBlock = false;
            currentMessageContainer = null;
            currentMessageContent = null;
        }
    }

// 添加一个基础的格式化函数，不依赖外部库
    function formatMessageBasic(content) {
        // 处理代码块
        let formatted = content.replace(/```(\w*)([\s\S]*?)```/g, function(match, language, code) {
            return '<pre><code class="language-' + language + '">' +
                escapeHtml(code.trim()) + '</code></pre>';
        });

        // 处理单行代码
        formatted = formatted.replace(/`([^`]+)`/g, '<code>' + escapeHtml('$1') + '</code>');

        // 处理标题 (# 标题)
        formatted = formatted.replace(/^(#{1,6})\s+(.+)$/gm, function(match, hashes, text) {
            const level = hashes.length;
            return '<h' + level + '>' + text + '</h' + level + '>';
        });

        // 处理粗体 (**文本**)
        formatted = formatted.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');

        // 处理斜体 (*文本*)
        formatted = formatted.replace(/\*([^*]+)\*/g, '<em>$1</em>');

        // 处理无序列表
        formatted = formatted.replace(/^- (.+)$/gm, '<li>$1</li>');
        formatted = formatted.replace(/(<li>.+<\/li>\n?)+/g, '<ul>$&</ul>');

        // 处理超链接 [文本](URL)
        formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank">$1</a>');

        // 处理换行
        formatted = formatted.replace(/\n/g, '<br>');

        return formatted;
    }

    /**
     * 停止生成
     */
    function stopGeneration() {
        if (!isGenerating) return;

        $.ajax({
            url: '/api/stream/chat/' + sessionId + '/stop',
            type: 'POST',
            success: function(response) {
                console.log('停止生成成功', response);

                // 在当前内容后添加停止标记
                if (currentMessageContent) {
                    currentMessageContent.append(
                        '<p class="generation-stopped">[生成已停止]</p>'
                    );
                }

                isGenerating = false;
                $('#stopGeneration').hide();
            },
            error: function(error) {
                console.error('停止生成失败', error);
                showToast('error', '操作失败', '停止生成失败，请稍后再试');
            }
        });
    }

    /**
     * 格式化消息
     */
    function formatMessage(content) {
        // 处理代码块
        let formatted = content.replace(/```(\w*)([\s\S]*?)```/g, function(match, language, code) {
            return '<pre><code class="language-' + language + '">' +
                code.trim() + '</code></pre>';
        });

        // 处理单行代码
        formatted = formatted.replace(/`([^`]+)`/g, '<code>$1</code>');

        // 处理换行
        formatted = formatted.replace(/\n/g, '<br>');

        return formatted;
    }

    /**
     * 格式化日期
     */
    function formatDate(date, format) {
        const year = date.getFullYear();
        const month = date.getMonth() + 1;
        const day = date.getDate();
        const hours = date.getHours();
        const minutes = date.getMinutes();
        const seconds = date.getSeconds();

        format = format.replace('yyyy', year);
        format = format.replace('MM', month.toString().padStart(2, '0'));
        format = format.replace('dd', day.toString().padStart(2, '0'));
        format = format.replace('HH', hours.toString().padStart(2, '0'));
        format = format.replace('mm', minutes.toString().padStart(2, '0'));
        format = format.replace('ss', seconds.toString().padStart(2, '0'));

        return format;
    }

    /**
     * 滚动到底部
     */
    function scrollToBottom() {
        const messageList = document.getElementById('messageList');
        messageList.scrollTop = messageList.scrollHeight;
    }
});


/**
 * 检查并加载所需的库
 */
function ensureLibrariesLoaded() {
    // 检查marked.js是否可用
    if (typeof marked === 'undefined') {
        console.warn('Marked.js不可用，尝试动态加载');

        // 创建script标签并加载marked.js
        const markedScript = document.createElement('script');
        markedScript.src = '/js/marked/marked.min.js';
        markedScript.onload = function() {
            console.log('Marked.js已动态加载');
            // 初始化marked
            if (typeof marked !== 'undefined') {
                marked.setOptions({
                    breaks: true,
                    gfm: true
                });
            }
        };
        markedScript.onerror = function() {
            console.error('无法加载Marked.js');
        };
        document.head.appendChild(markedScript);
    }

    // 检查Prism.js是否可用
    if (typeof Prism === 'undefined') {
        console.warn('Prism.js不可用，尝试动态加载');

        // 创建script标签并加载Prism.js
        const prismScript = document.createElement('script');
        prismScript.src = '/js/prism/prism.min.js';
        prismScript.onload = function() {
            console.log('Prism.js已动态加载');

            // 添加Prism样式
            if (!document.getElementById('prism-css')) {
                const prismCss = document.createElement('link');
                prismCss.id = 'prism-css';
                prismCss.rel = 'stylesheet';
                prismCss.href = '/js/prism/prism.css';
                document.head.appendChild(prismCss);
            }
        };
        prismScript.onerror = function() {
            console.error('无法加载Prism.js');
        };
        document.head.appendChild(prismScript);
    }
}